// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING

template<class, class> constexpr bool is_same = false;
template<class T> constexpr bool is_same<T, T> = true;

namespace test_star_this {
namespace ns1 {
class A {
  int x = 345;
  auto foo() {
    (void) [*this, this] { };  //expected-error{{'this' can appear only once}}
    (void) [this] { ++x; };
    (void) [*this] { ++x; };  //expected-error{{read-only variable}}
    (void) [*this] () mutable { ++x; };
    (void) [=] { return x; };
    (void) [&, this] { return x; };
    (void) [=, *this] { return x; };
    (void) [&, *this] { return x; };
  }
};
} // end ns1

namespace ns2 {
  class B {
    B(const B&) = delete; //expected-note{{deleted here}}
    int *x = (int *) 456;
    void foo() {
      (void)[this] { return x; };
      (void)[*this] { return x; }; //expected-error{{call to deleted}}
    }
  };
} // end ns2
namespace ns3 {
  class B {
    B(const B&) = delete; //expected-note2{{deleted here}}
    
    int *x = (int *) 456;
    public: 
    template<class T = int>
    void foo() {
      (void)[this] { return x; };
      (void)[*this] { return x; }; //expected-error2{{call to deleted}}
    }
    
    B() = default;
  } b;
  B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
} // end ns3

namespace ns4 {
template<class U>
class B {
  B(const B&) = delete; //expected-note{{deleted here}}
  double d = 3.14;
  public: 
  template<class T = int>
  auto foo() {
    const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}
      d += a; 
      return [this] (auto b) { return d +=b; }; 
    }; 
  }
  
  B() = default;
};
void main() {
  B<int*> b;
  b.foo(); //expected-note{{in instantiation}}
} // end main  
} // end ns4
namespace ns5 {

struct X {
  double d = 3.14;
  X(const volatile X&);
  void foo() {
      
  }
  
  void foo() const { //expected-note{{const}}
    
    auto L = [*this] () mutable { 
      static_assert(is_same<decltype(this), X*>);
      ++d;
      auto M = [this] { 
        static_assert(is_same<decltype(this), X*>);  
        ++d;
        auto N = [] {
          static_assert(is_same<decltype(this), X*>); 
        };
      };
    };
    
    auto L1 = [*this] { 
      static_assert(is_same<decltype(this), const X*>);
      auto M = [this] () mutable { 
        static_assert(is_same<decltype(this), const X*>);  
        auto N = [] {
          static_assert(is_same<decltype(this), const X*>); 
        };
      };
      auto M2 = [*this] () mutable { 
        static_assert(is_same<decltype(this), X*>);  
        auto N = [] {
          static_assert(is_same<decltype(this), X*>); 
        };
      };
    };
    
    auto GL1 = [*this] (auto a) { 
      static_assert(is_same<decltype(this), const X*>);
      auto M = [this] (auto b) mutable { 
        static_assert(is_same<decltype(this), const X*>);  
        auto N = [] (auto c) {
          static_assert(is_same<decltype(this), const X*>); 
        };
        return N;
      };
      
      auto M2 = [*this] (auto a) mutable { 
        static_assert(is_same<decltype(this), X*>);  
        auto N = [] (auto b) {
          static_assert(is_same<decltype(this), X*>); 
        };
        return N;
      };
      return [=](auto a) mutable { M(a)(a); M2(a)(a); };
    };
    
    GL1("abc")("abc");
    
    
    auto L2 = [this] () mutable {
      static_assert(is_same<decltype(this), const X*>);  
      ++d; //expected-error{{cannot assign}}
    };
    auto GL = [*this] (auto a) mutable {
      static_assert(is_same<decltype(this), X*>);
      ++d;
      auto M = [this] (auto b) { 
        static_assert(is_same<decltype(this), X*>);  
        ++d;
        auto N = [] (auto c) {
          static_assert(is_same<decltype(this), X*>); 
        };
        N(3.14);
      };
      M("abc");
    };
    GL(3.14);
 
  }
  void foo() volatile const {
    auto L = [this] () {
      static_assert(is_same<decltype(this), const volatile X*>);
      auto M = [*this] () mutable { 
        static_assert(is_same<decltype(this), X*>);
        auto N = [this] {
          static_assert(is_same<decltype(this), X*>);
          auto M = [] {
            static_assert(is_same<decltype(this), X*>);
          };
        };
        auto N2 = [*this] {
          static_assert(is_same<decltype(this), const X*>);
        };
      };
      auto M2 = [*this] () {
        static_assert(is_same<decltype(this), const X*>); 
        auto N = [this] {
          static_assert(is_same<decltype(this), const X*>);
        };
      };
    };
  }
  
};

} //end ns5
namespace ns6 {
struct X {
  double d;
  auto foo() const {
    auto L = [*this] () mutable {
      auto M = [=] (auto a) {
        auto N = [this] {
          ++d;
          static_assert(is_same<decltype(this), X*>);
          auto O = [*this] {
            static_assert(is_same<decltype(this), const X*>);
          };
        };
        N();
        static_assert(is_same<decltype(this), X*>);
      };
      return M;
    };
    return L;
  }
}; 

int main() {
  auto L = X{}.foo();
  auto M = L();
  M(3.14);
}
} // end ns6
namespace ns7 {

struct X {
  double d;
  X();
  X(const X&); 
  X(X&) = delete;
  auto foo() const {
    //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.
    const auto &&L = [*this] { };
  }
  
}; 
int main() {
  X x;
  x.foo();
}
} // end ns7

} //end ns test_star_this

